home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / PROGRAMM / CC_C / 1116.ZIP / TOOLKIT.ARC / STATS.H < prev    next >
Text File  |  1979-12-31  |  5KB  |  128 lines
  1.  
  2. /* STATS.H  written by Wayne Pearson
  3.    This Small C header file contains some first quadrant statistics.
  4.    min()   returns the minimum value in the data array passed to it.
  5.    max()   returns the maximum value in the data array passed to it.
  6.    size()  returns the number of data points in the data array.
  7.    occ()   returns the number of occurrences of a specified data value.
  8.    span()  returns the relative span of values in the data array.
  9.    lactd() returns the largest absolute contiguous temporal difference.
  10.    sactd() returns the smallest absolute contiguous temporal difference.
  11.    Valid function calls:
  12.                          mn = min(m,mn);
  13.                          mx = max(m,mx);
  14.                          s1 = size(data1,s1);
  15.                          o1 = occ(data1,255,o1); or  o1 = occ(data1,d1,o1);
  16.                          p1 = span(data1,p1);
  17.                          l1 = lactd(data1,l1);
  18.                          a1 = sactd(data1,a1);
  19. */
  20.  
  21. min(dat_min,dt_mn)
  22.                     int dat_min[],*dt_mn;
  23.                   {
  24.                     int datalen,min_val,min_lcv,data_val;
  25.                     datalen = min_lcv = 0; min_val = 255;
  26.                     datalen = size(dat_min,datalen);
  27.                     while(min_lcv < datalen)
  28.                           {
  29.                             data_val = dat_min[min_lcv];
  30.                             if(data_val < min_val) min_val = data_val;
  31.                             ++min_lcv;
  32.                           }
  33.                      dt_mn = min_val;
  34.                    }
  35.  
  36. max(dat_max,dt_mx)
  37.                     int dat_max[],*dt_mx;
  38.                   {
  39.                     int dt_len,max_val,max_lcv,dt_val;
  40.                     dt_len = max_lcv = max_val = 0;
  41.                     dt_len = size(dat_max,dt_len);
  42.                     while(max_lcv < dt_len)
  43.                           {
  44.                             dt_val = dat_max[max_lcv];
  45.                             if(dt_val > max_val) max_val = dt_val;
  46.                             ++max_lcv;
  47.                           }
  48.                      dt_mx = max_val;
  49.                    }
  50.  
  51. size(dat_size,size_)
  52.                      int dat_size[], *size_;
  53.        {
  54.          int l_cntr,ma_dat; l_cntr = 0; ma_dat = 1;
  55.          while(ma_dat != 0) { ma_dat = dat_size[l_cntr]; ++l_cntr; }
  56.          size_ = l_cntr - 1;
  57.        }
  58.  
  59. occ(occ_dat,occ_val,occ_n)
  60.                            int occ_dat[],occ_val,*occ_n;
  61.                         {
  62.                            int cho_ar,cho_n,cho_lcv,cho_len;
  63.                            cho_n = cho_lcv = cho_len = 0;
  64.                            cho_len = size(occ_dat,cho_len);
  65.                            while(cho_lcv < cho_len)
  66.                                  {
  67.                                    cho_ar = occ_dat[cho_lcv]; ++cho_lcv;
  68.                                    if(cho_ar == occ_val) ++cho_n;
  69.                                  }
  70.                            occ_n = cho_n;
  71.                         }
  72.  
  73. span(span_dat,span_)
  74.                       int span_dat[],*span_;
  75.                     {
  76.                       int s_min,s_max; s_min = s_max = 0;
  77.                       s_min = min(span_dat,s_min);
  78.                       s_max = max(span_dat,s_max);
  79.                       span_ = s_max - s_min;
  80.                     }
  81.  
  82. lactd(dt_lactd,lactd_)
  83.                         int dt_lactd[],*lactd_;
  84.                       {
  85.                         int dat_sz,lctd_lcv,lctd_val,dt_val1,dt_val2,dt_valx;
  86.                         dat_sz = lctd_lcv = lctd_val = 0;
  87.                         dat_sz = size(dt_lactd,dat_sz);
  88.                         while(lctd_lcv < (dat_sz - 1))
  89.                               {
  90.                                 dt_val1 = dt_lactd[lctd_lcv];
  91.                                 dt_val2 = dt_lactd[lctd_lcv + 1];
  92.                                 if(dt_val2 > dt_val1)
  93.                                    dt_valx = dt_val2 - dt_val1;
  94.                                 else dt_valx = dt_val1 - dt_val2;
  95.                                 if(dt_valx > lctd_val) lctd_val = dt_valx;
  96.                                 ++lctd_lcv;
  97.                               }
  98.                         lactd_ = lctd_val;
  99.                       }
  100.  
  101. sactd(dt_sactd,sactd_)
  102.                         int dt_sactd[],*sactd_;
  103.                       {
  104.                         int dt_sz,sctd_lcv,sctd_val,dt_vl1,dt_vl2,dt_vlx;
  105.                         dt_sz = sctd_lcv = 0; sctd_val = 255;
  106.                         dt_sz = size(dt_sactd,dt_sz);
  107.                         while(sctd_lcv < (dt_sz - 1))
  108.                               {
  109.                                 dt_vl1 = dt_sactd[sctd_lcv];
  110.                                 dt_vl2 = dt_sactd[sctd_lcv + 1];
  111.                                 if(dt_vl2 > dt_vl1)
  112.                                    dt_vlx = dt_vl2 - dt_vl1;
  113.                                 else dt_vlx = dt_vl1 - dt_vl2;
  114.                                 if(dt_vlx < sctd_val) sctd_val = dt_vlx;
  115.                                 ++sctd_lcv;
  116.                               }
  117.                         sactd_ = sctd_val;
  118.                       }
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.